__DefGroup UDP : [ALL]
  __Encoding
    field<12,  3> UPred upg=UPT;
    field<15,  1> PModi upg.not=False;

__DefOptype ULDC : [UDP]
  __Encoding
    field<0,  8> Optype optype==ULDC;
    field<16, 6> UReg urd;
    field<32, 22> CMem vb;
    field<80,  3> MEMDType dtype = 32;
  
  __Syntax
```asm
ULDC{.dtype} URd, c[UImm][URa+SImm]      $sched $req ;

.dtype = {.S8, .U8, .S1, .U1, .32*, .64, .128}
```

  __Description
从cmem读取数据至指定的UR寄存器，即URd = c[UImm][URa+SImm]。

  __OperandInfo
目的操作数URd必须来源于UR寄存器，位宽视读取的数据类型不同，可能是32bit、64bit或128bit。

关于位宽大于32bit的寄存器操作数的表示方法，请参考[扩展位宽的寄存器操作数](操作数汇编显示规则.md#扩展位宽的寄存器操作数)。

作为数据来源的cmem是一个常量内存可寻址操作数，可通过URa寄存器和立即数的组合寻址。

关于常量内存的可寻址操作数，请参考[常量内存可寻址操作数](操作数汇编显示规则.md#常量内存可寻址操作数)。

  __ModifierInfo
.dtype可取值.S8、.U8、.S16、.U16、.32、.64或.128（其中.32是默认值，此时可省略），表示读取的数据类型。

如果.dtype类型的位宽小于32bit，则在读取至32bit的目的操作数URd时，必须根据其为符号类型还是无符号类型，对数据进行符号扩展或零扩展。

  __Semantics
```asm
ULDC.dtype URd, c[UImm][URa+SImm]:
    n = sizeInBitsOf(.dtype);
    dtypeof(.dtype) t = c[UImm][URa+SImm];
    // 对低于32bit位宽的数据进行扩展
    if (n < 32) {
        URd = signOrZeroExtendTo32bit(t, .dtype);
    } else {
        URd = t;
    }
```

  __Examples
```asm
ULDC     UR0,     c[0x0][0x160];
ULDC.S8  UR1,     c[0x1][UR4-0x1];  // 需要符号扩展填充UR1
ULDC.128 UR[0:3], c[0x0][UR7+0x25];
```

__DefOpcode ULDC_U : [ULDC]
  __Encoding
    field<8,  4> USType stype==U;
    field<24, 6> UReg ura;

  __OperandInfo
    InList<upg, ura>;
    OutList<urd>;
    Order<upg, urd, C[vb, ura]>;
    Bitwidth<urd> = 32 + (dtype=="64")*32;
    Bitwidth<vb> = 32 + (dtype=="64")*32;
    Bitwidth<ura> = 32;

__DefOptype UIADD : [UDP]
  __Encoding
    field<0,  8> Optype optype == UIADD;
    field<16,  6> UReg urd;

    field<24,  6> UReg ura;
    field<72,  1> SignModi ura.neg = False;

    field<76,  1> IExt ext = NoX;

    field<98,  3> UPred upp = UPT;
    field<101,  1> PModi upp.not=True;
    field<106, 3> UPred upu = UPT;

  __Syntax
```asm
UIADD   URd,        {-}URa, {-}SrcB                $sched $req ;
UIADD.X URd{, upu}, {-}URa, {-}SrcB{, {!}upp}      $sched $req ;
```

  __Description
进行整数加法（通过Uniform Data Pipeline），即URd = URa + SrcB。

对二进制补码做加法，不区分有无符号。

  __OperandInfo
    AsmFormat<ura.neg> = CvtINegX(ura.neg, ext);

输出操作数URd和输入操作数URa必须来源于UR。

输入操作数SrcB的来源可以是UR、Imm32或cmem。

URa和SrcB都可以添加一个负号(-)前缀，表示取来源的相反数作为操作数。

启用.X修饰符后，需要额外2个操作数upu和upp，分别表示输出进位和输入进位：
| upu | upp |
|:--:|:--:|
| UPR | UPR |

操作数upp可以选择添加一个逻辑非(!)前缀，表示取反作为操作数。

upu的默认值是UPT，upp的默认值是!UPT，二者取默认值时均可省略。

在启用.X修饰符后，操作数URa、SrcB的可选前缀只能是按位取反(~)，不能是负号(-)。

  __ModifierInfo
.X修饰符表示带有输入/输出进位的扩展位宽加法。

  __Semantics
```asm
// 32bit整数加法
UIADD URd, URa, SrcB:
    t = URa + SrcB;
    URd = t[31:0];

// 带输入/输出进位的扩展位宽加法
UIADD.X URd, upu, URa, SrcB, upp:
    // 4294967296 = 2^32 = 0x100000000
    URd = mod(URa + SrcB + upp, 4294967296);
    upu = URa + SrcB + upp > 4294967296 ? true : false;
```

  __Examples
```asm
UIADD UR0, UR1,  UR2;
UIADD UR0, UR1, -UR2;
UIADD UR0, UR1, -0x114514;

UIADD.X UR0, UP0, UR2, UR4;
UIADD.X UR1, UPT, UR3, UR5, UP0;
```

__DefOpcode UIADD_UU : [UIADD]
  __Encoding
    field<8,   4> USType stype == UU;
    field<32,  6> UReg urb;
    field<97,  1> SignModi urb.neg = False;
  __OperandInfo
    InList<upg, ura, urb, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, urb, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<urd> = 32;
    AsmFormat<urb.neg> = CvtINegX(urb.neg, ext);

__DefOpcode UIADD_UI : [UIADD]
  __Encoding
    field<8,   4> USType stype == UI;
    field<32, 32> SImm32 vb;
  __OperandInfo
    InList<upg, ura, vb, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, vb, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UIADD_UC : [UIADD]
  __Encoding
    field<8,   4> USType stype == UC;
    field<32, 22> CMem vb;
    field<97,  1> SignModi vb.neg = False;
  __OperandInfo
    InList<upg, ura, vb, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, vb, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;
    AsmFormat<vb.neg> = CvtINegX(vb.neg, ext);

__DefOptype UIMAD : [UDP]
  __Encoding
    field<0,   8> Optype optype == UIMAD;
    field<16,  6> UReg urd;

    field<24,  6> UReg ura;

    field<75,  1> LOHI lohi = LO;
    field<76,  1> IExt ext = NoX;
    field<77,  1> IType itype = S32;

    field<98,  3> UPred upp = UPT;
    field<101,  1> PModi upp.not=True;
    field<106, 3> UPred upu = UPT;

  __Syntax
```asm
UIMAD{.LO}{.itype} URd{, upu}, URa, SrcB, {-}SrcC                $sched $req ; // 低32bit模式
UIMAD.HI.X{.itype} URd{, upu}, URa, SrcB, {-}SrcC{, {!}upp}      $sched $req ; // 扩展位宽模式

.itype = {.S32*, .U32}
```

  __Description
进行整数乘加运算，即URd = URa * SrcB + SrcC。

视启用的修饰符的不同，有2种不同的模式：
- 低32bit模式：启用.LO修饰符，URd = URa * SrcB + SrcC，输出进位upu。
- 扩展位宽模式：启用.HI.X修饰符，URd = (URa * SrcB) >> 32 + SrcC + upp。

每一种模式的准确语义请参考Semantics部分。

  __OperandInfo
操作数URd和URa必须来源于UR。

操作数SrcB和SrcC的合法来源组合如下：

| SrcB | SrcC |
|:--:|:--:|
| UR  | UR  |
| UR  |Imm32|
|Imm32| UR  |
| UR  |cmem |
|cmem | UR  |

启用.LO修饰符时，操作数SrcC可以选择添加一个负号(-)前缀，表示取相反数作为操作数。

启用.HI和.X修饰符时，操作数SrcC可以选择添加按位取反(~)前缀，表示对SrcC按位取反作为操作数。

2个谓词操作数upu和upp，分别表示输出进位和输入进位：

| upu | upp |
|:--:|:--:|
| UPR | UPR |

操作数upp可以选择添加一个逻辑非(!)前缀，表示取反作为操作数。

upu的默认值是UPT，upp的默认值是!UPT，二者取默认值时均可省略。

  __ModifierInfo
启用.LO修饰符时，表示取URa*SrcB乘积的低32bit（以二进制补码的形式）与SrcC相加，结果写入URd，并输出进位upu。

启用.HI和.X修饰符时，表示取URa*SrcB乘积的高32bit（以二进制补码的形式）与SrcC和输入进位upp相加，结果写入URd。

.itype可取值.S32（默认，可省略）或.U32，分别表示将URa和SrcB视为有符号数或无符号数进行乘法。

  __Semantics
```asm
// 低32bit模式
UIMAD.LO.itype URd, upu, URa, SrcB, SrcC:
    if (.itype == .S32)
        URa = INT32(URa);
        SrcB = INT32(SrcB);
    else
        URa = UINT32(URa);
        SrcB = UINT32(SrcB);
    t = URa * SrcB;
    // 4294967296 = 2^32 = 0x100000000
    URd = mod(t[31:0] + SrcC, 4294967296);
    upu = t[31:0] + SrcC > 4294967296 ? true : false;

// 扩展位宽模式
UIMAD.HI.X.itype URd, upu, URa, SrcB, SrcC, upp:
    if (.itype == .S32)
        URa = INT32(URa);
        SrcB = INT32(SrcB);
    else
        URa = UINT32(URa);
        SrcB = UINT32(SrcB);
    t = URa * SrcB;
    // 4294967296 = 2^32 = 0x100000000
    URd = mod(t[63:32] + SrcC + upp, 4294967296);
    upu = t[63:32] + SrcC + upp > 4294967296 ? true : false;
```

  __Examples
```asm
UIMAD UR0, UR1, UR2, UR3;    // UR0 = UR1 * UR2 + UR3

UIMAD.U32      UR0, UP0, UR2, 0x114514, UR4,   ;
UIMAD.HI.X.U32 UR1,      UR2, 0x114514, UR5, UP0; // UR[0:1] = UR2 * 0x114514 + UR[4:5]

UIMAD      UR0, P0, UR2, UR3, -UR4    ;
UIMAD.HI.X UR1,     UR2, UR3, ~UR5, UP0; // UR[0:1] = UR2 * UR3 - UR[4:5]
```

__DefOpcode UIMAD_UUU : [UIMAD]
  __Encoding
    field<8,   4> USType stype == UUU;
    field<32,  6> UReg urb;

    field<64,  6> UReg urc;
    field<74,  1> SignModi urc.neg = False;
  __OperandInfo
    InList<upg, ura, urb, urc, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, urb, urc, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;
    AsmFormat<urc.neg> = CvtINegX(urc.neg, ext);

__DefOpcode UIMAD_UUI : [UIMAD]
  __Encoding
    field<8,   4> USType stype == UUI;
    field<32, 32> SImm32 vc;
    field<64,  6> UReg urb;
  __OperandInfo
    InList<upg, ura, urb, vc, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, urb, vc, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<vc> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UIMAD_UIU : [UIMAD]
  __Encoding
    field<8,   4> USType stype == UIU;
    field<32, 32> SImm32 vb;
    field<64,  6> UReg urc;
    field<74,  1> SignModi urc.neg = False;
  __OperandInfo
    InList<upg, ura, vb, urc, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, vb, urc, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;
    AsmFormat<urc.neg> = CvtINegX(urc.neg, ext);

__DefOpcode UIMAD_UUC : [UIMAD]
  __Encoding
    field<8,   4> USType stype == UUC;
    field<32, 22> CMem vc;
    field<97,  1> SignModi vc.neg = False;
    field<64,  6> UReg urb;
  __OperandInfo
    InList<upg, ura, urb, vc, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, urb, vc, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<vc> = 32;
    Bitwidth<urd> = 32;
    AsmFormat<vc.neg> = CvtINegX(vc.neg, ext);

__DefOpcode UIMAD_UCU : [UIMAD]
  __Encoding
    field<8,   4> USType stype == UCU;
    field<32, 22> CMem vb;

    field<64,  6> UReg urc;
    field<74,  1> SignModi urc.neg = False;
  __OperandInfo
    InList<upg, ura, vb, urc, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, vb, urc, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;
    AsmFormat<urc.neg> = CvtINegX(urc.neg, ext);

__DefOptype UIMAD_WIDE : [UDP]
  __Encoding
    field<0,  8> Optype optype == UIMAD_WIDE;
    field<16,  6> UReg urd;

    field<24,  6> UReg ura;

    field<76,  1> IExt ext = NoX;
    field<77,  1> IType itype = S32;

    field<98,  3> UPred upp = UPT;
    field<101,  1> PModi upp.not=True;
    field<106, 3> UPred upu = UPT;

  __Syntax
```asm
UIMAD.WIDE.itype   URd{, upu}, URa, SrcB, {-}SrcC                $sched $req ; // 64bit模式
UIMAD.WIDE.X.itype URd{, upu}, URa, SrcB, {-}SrcC{, {!}upp}      $sched $req ; // 扩展位宽模式

.itype = {.S32*, .U32}
```

  __Description
进行64bit整数乘加运算，即URd = URa * SrcB + SrcC，其中URa和SrcB都是32bit整数，URd和SrcC都是64bit整数，先计算32bit整数乘法，乘积再进行64bit整数加法。

  __OperandInfo
操作数URd和URa必须来源于UR。

操作数SrcB和SrcC的合法来源组合如下：

| SrcB | SrcC |
|:--:|:--:|
| UR  | UR  |
| Imm32 | UR  |
| UR  | cmem|
| cmem| UR  |

操作数SrcC可以选择添加一个负号(-)前缀，表示取相反数作为操作数。但在启用.X修饰符后，SrcC的可选前缀只能是按位取反(~)，不能是负号(-)。

URd和SrcC必须是64bit整数操作数，如果来源是寄存器，则必须是由连续两个32bit寄存器拼接而成的，例如UR[0:1]。

输入谓词操作数upp的默认值是!UPT（此时可省略），可以选择添加一个逻辑非(!)前缀，表示取反作为操作数。

输出谓词操作数upu的默认值是UPT（此时可省略）。

  __ModifierInfo
.itype可取值.S32（默认，可省略）或.U32，分别表示将URa和SrcB视为有符号数或无符号数进行乘法计算。

启用.X修饰符表示进行带输入/输出进位的扩展位宽加法，即URd = URa*SrcB + SrcC + upp，并输出进位upu。

  __Semantics
```asm
// 64bit模式
UIMAD.WIDE.itype URd, upu, URa, SrcB, SrcC:
    if (.itype == .S32)
        URa = INT32(URa);
        SrcB = INT32(SrcB);
    else
        URa = UINT32(URa);
        SrcB = UINT32(SrcB);
    t = URa * SrcB;
    URd = mod(t + SrcC, 1<<64);
    upu = t + SrcC > (1<<64) ? true : false;

// 扩展位宽模式
UIMAD.WIDE.X.itype URd, upu, URa, SrcB, SrcC, upp:
    if (.itype == .S32)
        URa = INT32(URa);
        SrcB = INT32(SrcB);
    else
        URa = UINT32(URa);
        SrcB = UINT32(SrcB);
    t = URa * SrcB;
    URd = mod(t + SrcC + upp, 1<<64);
    upu = t + SrcC + upp > (1<<64) ? true : false;
```

  __Examples
```asm
UIMAD.WIDE     UR[0:1], UR2,      UR3,  UR[4:5];
UIMAD.WIDE.U32 UR[0:1], UR2, 0x114514, -UR[4:5];

UIMAD.WIDE.X UR[0:1], UP0, UR4, UR5, UR[6:7]     ;
UIMAD.WIDE.X UR[2:3],      URZ, URZ,     URZ, UP0;
```

__DefOpcode UIMAD_WIDE_UUU : [UIMAD_WIDE]
  __Encoding
    field<8,   4> USType stype == UUU;
    field<32,  6> UReg urb;
    field<64,  6> UReg urc;
    field<74,  1> SignModi urc.neg = False;
  __OperandInfo
    InList<upg, ura, urb, urc, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, urb, urc, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<urc> = 64;
    Bitwidth<urd> = 64;
    AsmFormat<urc.neg> = CvtINegX(urc.neg, ext);

__DefOpcode UIMAD_WIDE_UIU : [UIMAD_WIDE]
  __Encoding
    field<8,   4> USType stype == UIU;
    field<32, 32> SImm32 vb;
    field<64,  6> UReg urc;
    field<74,  1> SignModi urc.neg = False;
  __OperandInfo
    InList<upg, ura, vb, urc, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, vb, urc, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urc> = 64;
    Bitwidth<urd> = 64;
    AsmFormat<urc.neg> = CvtINegX(urc.neg, ext);

__DefOpcode UIMAD_WIDE_UUC : [UIMAD_WIDE]
  __Encoding
    field<8,   4> USType stype == UUC;
    field<32, 22> CMem vc;
    field<97,  1> SignModi vc.neg = False;
    field<64,  6> UReg urb;
  __OperandInfo
    InList<upg, ura, urb, vc, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, urb, vc, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<vc> = 32;
    Bitwidth<urd> = 32;
    AsmFormat<vc.neg> = CvtINegX(vc.neg, ext);

__DefOpcode UIMAD_WIDE_UCU : [UIMAD_WIDE]
  __Encoding
    field<8,   4> USType stype == UCU;
    field<32, 22> CMem vb;

    field<64,  6> UReg urc;
    field<74,  1> SignModi urc.neg = False;
  __OperandInfo
    InList<upg, ura, vb, urc, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, vb, urc, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urc> = 64;
    Bitwidth<urd> = 64;
    AsmFormat<urc.neg> = CvtINegX(urc.neg, ext);

__DefOptype UIMUL : [UDP]
  __Encoding
    field<0,  8> Optype optype == UIMUL;
    field<16,  6> UReg urd;

    field<24,  6> UReg ura;

    field<75,  1> LOHI lohi = LO;
    field<77,  1> IType itype = S32;

  __Syntax
```asm
UIMUL{.lohi}{.itype} URd, URa, {-}SrcB      $sched $req ;

.lohi = {.LO*, .HI}
.itype = {.S32*, .U32}
```

  __Description
进行32bit整数乘法运算（使用Uniform Data Pipeline），即URd = URa * SrcB。

  __OperandInfo
URa和URd必须来源于UR。

SrcB可以是UR、Imm32或cmem。且可以添加一个负号(-)前缀，表示取相反数作为操作数。

  __ModifierInfo
.lohi可取值.LO（默认，可省略）或.HI，分别表示取URa*SrcB结果的低32bit或高32bit输出。

.itype可取值.S32（默认，可省略）或.U32，分别表示将URa、SrcB视为有符号数或无符号数。

  __Semantics
```asm
UIMUL.lohi.itype URd, URa, SrcB:
    if (.itype == .S32)
        URa = INT32(URa);
        SrcB = INT32(SrcB);
    else
        URa = UINT32(URa);
        SrcB = UINT32(SrcB);
    t = URa * SrcB;
    if (.lohi == .LO)
        URd = t[31:0];
    else
        URd = t[63:32];
```

  __Examples
```asm
UIMUL UR0, UR1, UR2;
UIMUL.HI.U32 UR0, UR1, 0x114514;
```

__DefOpcode UIMUL_UU : [UIMUL]
  __Encoding
    field<8,   4> USType stype == UU;
    field<32,  6> UReg urb;
    field<97,  1> SignModi urb.neg = False;
  __OperandInfo
    InList<upg, ura, urb>;
    OutList<urd>;
    Order<upg, urd, ura, urb>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UIMUL_UI : [UIMUL]
  __Encoding
    field<8,   4> USType stype == UI;
    field<32, 32> SImm32 vb;
  __OperandInfo
    InList<upg, ura, vb>;
    OutList<urd>;
    Order<upg, urd, ura, vb>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UIMUL_UC : [UIMUL]
  __Encoding
    field<8,   4> USType stype == UC;
    field<32, 22> CMem vb;
    field<97,  1> SignModi vb.neg = False;
  __OperandInfo
    InList<upg, ura, vb>;
    OutList<urd>;
    Order<upg, urd, ura, vb>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOptype ULEA : [UDP]
  __Encoding
    field<0,  8> Optype optype == ULEA;
    field<16,  6> UReg urd;

    field<24,  6> UReg ura;
    field<72,  1> SignModi ura.neg = False;

    field<75,  1> LOHI lohi = LO;
    field<76,  1> IExt ext = NoX;
    field<80,  1> LEASX32 sx32 = NoSX32;
    field<82,  5> UImm5 shiftamt;

    field<98,  3> UPred upp = UPT;
    field<101,  1> PModi upp.not=True;
    field<106, 3> UPred upu = UPT;

  __Syntax
```asm
ULEA{.LO}      URd{, upu}, {-}URa, SrcB,      UImm5Sca                $sched $req ; // 32bit模式
ULEA.HI.X      URd{, upu}, {-}URa, SrcB, URc, UImm5Sca{, {!}upp}      $sched $req ; // 扩展位宽模式
ULEA.HI.X.SX32 URd{, upu}, {-}URa, SrcB,      UImm5Sca{, {!}upp}      $sched $req ; // 符号扩展模式
```

  __Description
对整数进行2的幂缩放后，与基址相加（使用Uniform Data Pipeline）。

根据修饰符的不同，分为3种模式：
- 32bit模式：URd,upu = (URa << UImm5Sca) & 0xFFFFFFFF + SrcB;
- 扩展位宽模式：URd,upu = (({URc,URa} << UImm5Sca)>>32) & 0xFFFFFFFF + SrcB + upp;
- 符号扩展模式：URd,upu = ((INT64(URa) << UImm5Sca)>>32) & 0xFFFFFFFF + SrcB + upp;

每种模式的具体语义请参考Semantics部分。

  __OperandInfo
    AsmFormat<ura.neg> = CvtINegX(ura.neg, ext);
  
操作数URd、URa和URc必须来源于UR。

其中URc操作数只在扩展位宽模式下使用。

32bit模式下，URa可以选择添加一个负号(-)前缀，表示取相反数作为操作数。

扩展位宽模式下，URa可以选择添加一个按位取反(~)前缀，表示对URa和URc组成的64bit输入{URc, URa}按位取反作为输入。

符号扩展模式下，URa可以选择添加一个按位取反(~)前缀，表示URa按位取反作为输入。

操作数SrcB的合法来源包括UR、Imm32和cmem。

UImm5Sca是一个5bit的无符号立即数（0~31），以2的幂表示缩放（scaling）的倍数，具体参考Semantics部分。

操作数upu和upp，分别表示输出进位和输入进位：

| upu | upp |
|:--:|:--:|
| UPR | UPR |

操作数upp可以选择添加一个逻辑非(!)前缀，表示取反作为操作数。

upu的默认值是UPT，upp的默认值是!UPT，二者取默认值时均可省略。

  __ModifierInfo
启用.LO修饰符时，表示取URa缩放后的结果低32bit与SrcB相加，这是指令的默认模式，.LO也可以省略。

启用.HI.X修饰符时，表示进行扩展位宽的计算，此时以{URc, URa}作为64bit整数（URc在高位，URa在低位），取缩放结果的高32bit与SrcB和输入进位upp相加，结果写入URd，并输出进位upu。

同时启用.HI.X和.SX32修饰符时，表示直接将有符号整数URa符号扩展到64bit，再进行计算。

  __Semantics
```asm
ULEA.LO URd, upu, URa, SrcB, UImm5Sca:
    // 左移UImm5Sca位，等价于放大2^UImm5Sca倍
    t = URa << UImm5Sca;
    addr = t & 0xFFFFFFFF + SrcB;
    // 4294967296 = 2^32 = 0x100000000
    URd = mod(addr, 4294967296);
    upu = addr > 4294967296 ? true : false;

ULEA.HI.X URd, upu, URa, SrcB, URc, UImm5Sca, upp:
    UINT64 t;
    t[63:32] = URc[31:0];
    t[31:0] = URa[31:0];
    // 先左移UImm5Sca位，再取高32位
    t = t >> (32 - UImm5Sca);
    addrHi = t & 0xFFFFFFFF + SrcB + upp;
    // 4294967296 = 2^32 = 0x100000000
    URd = mod(addrHi, 4294967296);
    upu = addrHi > 4294967296 ? true : false;    

ULEA.HI.X.SX32 URd, upu, URa, SrcB, UImm5Sca, upp:
    // 将URa符号扩展到64bit
    INT64 t = signExtendTo64bit(URa);
    // 先左移UImm5Sca位，再取高32位
    t = t >> (32 - UImm5Sca);
    addrHi = t & 0xFFFFFFFF + SrcB + upp;
    // 4294967296 = 2^32 = 0x100000000
    URd = mod(addrHi, 4294967296);
    upu = addrHi > 4294967296 ? true : false;
```

  __Examples
```asm
ULEA UR0, UR1, 0x10, UR3; // UR0 = (UR1 << 16) + UR3

ULEA      UR0, UP0, UR2, cmem[0x0][0x160], UR7, URZ     ;
ULEA.HI.X UR1,      UR2, cmem[0x0][0x160], UR7, URZ, UP0; // 联合完成UR[0:1] = {UR7,UR2} << cmem[0x0][0x160]

ULEA           UR0, UP0, -UR2, UR3, UR4     ;
ULEA.HI.X.SX32 UR1,      ~UR2, UR3, UR5, UP0; // 联合完成UR[0:1]=-UR2<<UR3 + UR[4:5]
```

__DefOpcode ULEA_UUU : [ULEA]
  __Encoding
    field<8,   4> USType stype == UUU;
    field<32,  6> UReg urb;
    field<64,  6> UReg urc;
    field<97,  1> SignModi urb.neg = False;
  __OperandInfo
    InList<upg, ura, urb, urc, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, urb, urc, shiftamt, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;
    AsmFormat<urb.neg> = CvtINegX(urb.neg, ext);

__DefOpcode ULEA_UIU : [ULEA]
  __Encoding
    field<8,   4> USType stype == UIU;
    field<32, 32> SImm32 vb;
    field<64,  6> UReg urc;
  __OperandInfo
    InList<upg, ura, vb, urc, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, vb, urc, shiftamt, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;

__DefOpcode ULEA_UCU : [ULEA]
  __Encoding
    field<8,   4> USType stype == UCU;
    field<32, 22> CMem vb;
    field<64,  6> UReg urc;
    field<97,  1> SignModi vb.neg = False;
  __OperandInfo
    InList<upg, ura, vb, urc, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, vb, urc, shiftamt, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;
    AsmFormat<vb.neg> = CvtINegX(vb.neg, ext);

__DefOptype UIABS : [UDP]
  __Encoding
    field<0,  8> Optype optype == UIABS;
    field<16,  6> UReg urd;

  __Syntax
```asm
UIABS URd, {-}SrcB      $sched $req ;
```

  __Description
对32bit有符号整数取绝对值（使用Uniform Data Pipeline），即URd = |SrcB|。

  __OperandInfo
输出操作数URd来源必须是UR。

输入操作数SrcB的合法来源可以是UR、SImm32或cmem，且允许添加一个负号（-）前缀，表示对来源取相反数作为操作数。

  __Semantics
```asm
UIABS URd, SrcB:
    URd = |SrcB|;
```

  __Examples
```asm
UIABS UR0, UR1;
UIABS UR0, 0xFFFFFFFF;  // UR0 = |-1| = 0x1
```

__DefOpcode UIABS_U : [UIABS]
  __Encoding
    field<8,   4> USType stype == U;
    field<32,  6> UReg urb;
  __OperandInfo
    InList<upg, urb>;
    OutList<urd>;
    Order<upg, urd, urb>;
    Bitwidth<urb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UIABS_I : [UIABS]
  __Encoding
    field<8,   4> USType stype == I;
    field<32, 32> SImm32 vb;
  __OperandInfo
    InList<upg, vb>;
    OutList<urd>;
    Order<upg, urd, vb>;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UIABS_C : [UIABS]
  __Encoding
    field<8,   4> USType stype == C;
    field<32, 22> CMem vb;
  __OperandInfo
    InList<upg, vb>;
    OutList<urd>;
    Order<upg, urd, vb>;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOptype UIMNMX : [UDP]
  __Encoding
    field<0,   8> Optype optype == UIMNMX;
    field<16,  6> UReg urd;

    field<24,  6> UReg ura;

    field<77,  1> IType itype = S32;

    field<98,  3> UPred upp;
    field<101,  1> PModi upp.not=False;

  __Syntax
```asm
UIMNMX{.itype} URd, {-}URa, {-}SrcB, {!}upp      $sched $req ;

.itype = {.S32*, .U32}
```

  __Description
选取输入整数的最大/最小值输出（使用Uniform Data Pipeline）：
- upp = true ，输出最小值
- upp = false，输出最大值

  __OperandInfo
URd和URa必须来源于GPR。

SrcB可以来源于GPR、UR、Imm32或cmem。

URa和SrcB可以添加一个负号（-）前缀，表示取来源的相反数作为操作数。

upp必须来源于PR，且可以添加一个逻辑非（!）前缀，表示取反作为操作数。

  __ModifierInfo
.itype可取值.S32（默认，可省略）或.U32，分别表示将URa、SrcB视为有符号数或无符号数。

  __Semantics
```asm
IABS.type URd, URa, SrcB, upp:
    URd = upp ? min(URa, SrcB) : max(URa, SrcB);
```

  __Examples
```asm
UIMNMX UR0, UR1, UR2, !UPT;
UIMNMX UR0, UR1, 0x0,  UP0;
```

__DefOpcode UIMNMX_UU : [UIMNMX]
  __Encoding
    field<8,   4> USType stype == UU;
    field<32,  6> UReg urb;
  __OperandInfo
    InList<upg, ura, urb, upp>;
    OutList<urd>;
    Order<upg, urd, ura, urb, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UIMNMX_UI : [UIMNMX]
  __Encoding
    field<8,   4> USType stype == UI;
    field<32, 32> SImm32 vb;
  __OperandInfo
    InList<upg, ura, vb, upp>;
    OutList<urd>;
    Order<upg, urd, ura, vb, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UIMNMX_UC : [UIMNMX]
  __Encoding
    field<8,   4> USType stype == UC;
    field<32, 22> CMem vb;
  __OperandInfo
    InList<upg, ura, vb, upp>;
    OutList<urd>;
    Order<upg, urd, ura, vb, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOptype UP2UR : [UDP]
  __Encoding
    field<0,  8> Optype optype == UP2UR;
    field<16,  6> UReg urd;

    field<24, 6> UReg ura;
    field<79,  2> BSel bsel = B0;

  __Syntax
```asm          
UP2UR{.bsel} URd, UPR, URa, SbMsk      $sched $req ;

.bsel = {.B0*, .B1, .B2, .B3}
```

  __Description
根据SbMsk的低8bit，从寄存器URa和Uniform谓词寄存器UP0~UP7中选取一部分或全部，复制到结果寄存器中的指定位置。

  __OperandInfo
URd和URa均来源于UR。

汇编助记符UPR代表所有uniform谓词寄存器UP0~UP7构成的集合，在指令书写/显示中不可变，可理解为汇编显示规则的一部分，而非指令操作数。

SbMsk的合法来源包括UR、Imm32和cmem。

  __ModifierInfo
.bsel的可取值包括.B0（默认值，可省略）、.B1、.B2和.B3，分别表示将结果复制到URd的32bit中的哪些位，具体含义请参考Semantics部分。

  __Semantics
```asm
UP2UR.bsel URd, UPR, URa, SbMsk:
    // 将uniform predicate寄存器UP0~UP7的值打包成一个8bit数upr
    // upr的LSB是UP0，MSB是UP7
    upr = UINT8(0);
    upr = packPred2Byte(UP0,UP1,UP2,UP3,UP4,UP5,UP6,UP7);
    // 根据.bsel和SbMsk的低8bit，将upr和URa中特定bit复制给URd:
    // 如果SbMsk的第i位是1，则复制upr的第i位，否则复制URa的相应位（i=0~7）
    b_select = SbMsk[0:7];
    switch (.bsel) {
        case .B0: 
            URd[0:7] = (b_select & upr) | ((~b_select) & URa[0:7]); 
            break;
        case .B1: 
            URd[8:15] = (b_select & upr) | ((~b_select) & URa[8:15]);
            break;
        case .B2: 
            URd[16:23] = (b_select & upr) | ((~b_select) & URa[16:23]);
            break;
        case .B3: 
            URd[24:31] = (b_select & upr) | ((~b_select) & URa[24:31]);
            break;
    }
```

  __Examples
```asm
UP2UR.B1 UR7, UPR, UR0, 0xFF;
```

__DefOpcode UP2UR_UU : [UP2UR]
  __Encoding
    field<8,   4> USType stype == UU;
    field<32,  6> UReg urb;
  __OperandInfo
    InList<upg, ura, UPR, urb>;
    OutList<urd>;
    Order<upg, urd, UPR, ura, urb>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UP2UR_UI : [UP2UR]
  __Encoding
    field<8,   4> USType stype == UI;
    field<32, 32> SImm32 vb;
  __OperandInfo
    InList<upg, ura, UPR, vb>;
    OutList<urd>;
    Order<upg, urd, UPR, ura, vb>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UP2UR_UC : [UP2UR]
  __Encoding
    field<8,   4> USType stype == UC;
    field<32, 22> CMem vb;
  __OperandInfo
    InList<upg, ura, UPR, vb>;
    OutList<urd>;
    Order<upg, urd, UPR, ura, vb>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOptype UR2UP : [UDP]
  __Encoding
    field<0,  8> Optype optype == UR2UP;
    field<24, 6> UReg ura;
    field<79,  2> BSel ura.bsel = B0;

  __Syntax
```asm          
UR2UP UPR, URa{.bsel}, SbMsk      $sched $req ;

.bsel = {.B0*, .B1, .B2, .B3}
```

  __Description
根据SbMsk的低8bit，从Uniform寄存器URa中选取一部分，复制到Uniform谓词寄存器UP0~UP7中。

  __OperandInfo
汇编助记符UPR代表所有Uniform谓词寄存器UP0~UP7构成的集合，在指令书写/显示中不可变，可理解为汇编显示规则的一部分，而非指令操作数。

URa来源于UR，可以带有一个后缀修饰符.bsel。

.bsel的可取值包括.B0（默认值，可省略）、.B1、.B2和.B3，分别表示将URa的32bit中选取哪些比特，具体含义请参考Semantics部分。

SbMsk的合法来源包括Imm32、cmem和UR。

  __Semantics
```asm
UR2UP UPR, URa.bsel, SbMsk:
    // 将predicate寄存器UP0~UP7的值打包成一个8bit数upr
    // upr的LSB是P0，MSB是P7
    upr = UINT8(0);
    upr = packPred2Byte(UP0,UP1,UP2,UP3,UP4,UP5,UP6,UP7);
    // 根据.bsel和SbMsk的低8bit，将URa中特定bit复制给upr:
    b_select = SbMsk[0:7];
    switch (.bsel) {
        case .B0: 
            upr = b_select & URa[0:7]; 
            break;
        case .B1: 
            upr = b_select & URa[8:15];
            break;
        case .B2: 
            upr = b_select & URa[16:23];
            break;
        case .B3: 
            upr = b_select & URa[24:31];
            break;
    }
    // 将upr的8bit分别复制给UP0~UP7
    // upr的LSB复制给UP0，MSB复制给UP7
    UP0,UP1,UP2,UP3,UP4,UP5,UP6,UP7 = unpackByte2Bits(upr);
```

  __Examples
```asm
UR2UP UPR, UR7.B1, 0xFF;
```

__DefOpcode UR2UP_UU : [UR2UP]
  __Encoding
    field<8,   4> USType stype == UU;
    field<32,  6> UReg urb;
  __OperandInfo
    InList<upg, ura, urb>;
    OutList<UPR>;
    Order<upg, UPR, ura, urb>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;

__DefOpcode UR2UP_UI : [UR2UP]
  __Encoding
    field<8,   4> USType stype == UI;
    field<32, 32> SImm32 vb;
  __OperandInfo
    InList<upg, ura, vb>;
    OutList<UPR>;
    Order<upg, UPR, ura, vb>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;

__DefOpcode UR2UP_UC : [UR2UP]
  __Encoding
    field<8,   4> USType stype == UC;
    field<32, 22> CMem vb;
  __OperandInfo
    InList<upg, ura, vb>;
    OutList<UPR>;
    Order<upg, UPR, ura, vb>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;

__DefOptype UISETP : [UDP]
  __Encoding
    field<0,  8> Optype optype == UISETP;
    field<24, 6> UReg ura;

    field<76,  1> IExt ext = NoX;
    field<77,  1> IType itype = S32;
    field<79,  3> CompOp compop;
    field<82,  2> BoolOp boolop;

    field<98,  3> UPred upp;
    field<101,  1> PModi upp.not=False;
    field<102, 3> UPred upq = UPT;
    field<105, 1> PModi upq.not=False;
    field<106, 3> UPred upu;
    field<109, 3> UPred upv = UPT;

  __Syntax
```asm          
UISETP.compop.boolop.itype   upu{, upv}, URa, SrcB, {!}upp                $sched $req ;
UISETP.compop.boolop.itype.X upu{, upv}, URa, SrcB, {!}upp{, {!}upq}      $sched $req ;

.compop = {.EQ, .NE, .LT, .LE, .GT, .GE}
.boolop = {.AND, .OR, .XOR}
.itype = {.S32*, .U32}
```

  __Description
对2个输入整数进行指定的算术比较（使用Uniform Data Pipeline），将比较结果（布尔值）与一个额外的输入谓词进行指定的布尔运算，得到输出。

  __OperandInfo
URa只能来源于UR。

SrcB可以是UR、Imm32或cmem。

输出操作数upu、upv，输入操作数upp、upq均为谓词，来源只能是UPR。

输出操作数upv的默认值是UPT（可以省略），表示舍弃upv的计算结果。

输入操作数upp和upq可以添加一个逻辑非(!)前缀，表示取反作为操作数。其中upq的默认值是!UPT（可以省略）。

  __ModifierInfo
.compop决定对URa、SrcB所作的算术比较，其可取值及其对应的比较操作为：

| .compop | 功能 |
|:--:|:--:|
| .EQ | == |
| .NE | != |
| .LT | <  |
| .LE | <= |
| .GT | >  |
| .GE | >= |

.boolop决定了将URa、SrcB的比较结果与输入布尔值（操作数upp）进行何种布尔运算：

| .boolop | 功能 |
|:--:|:--:|
| .AND | && |
| .OR  | \|\| |
| .XOR | ^ |

.itype可取值.S32（默认，可省略）或.U32，分别表示将URa、SrcB视为有符号数或无符号数。

.X表示对扩展位宽的整数进行比较。

  __Semantics
```asm
// 32bit整数比较
UISETP.compop.boolop.itype upu, upv, URa, SrcB, upp:
    if (.itype == .S32)
        URa = INT32(URa);
        SrcB = INT32(SrcB);
    else
        URa = UINT32(URa);
        SrcB = UINT32(SrcB);
    t = URa compop SrcB ? true : false;
    upu = t boolop upp;
    upv = (!t) boolop upp;

// 扩展位宽的整数比较
UISETP.compop.boolop.itype.X upu, upv, URa, SrcB, upp, upq:
    if (.itype == .S32)
        URa = INT32(URa);
        SrcB = INT32(SrcB);
    else
        URa = UINT32(URa);
        SrcB = UINT32(SrcB);
    if (URa == SrcB) 
        upu = upq boolop upp;
        upv = (!upq) boolop upp;
    else
        t = URa compop SrcB ? true : false;
        upu = t boolop upp;
        upv = (!t) boolop upp;
```

  __Examples
```asm
UISETP.LE.U32.AND UP0, UPT, UR4, UR6, UPT     ;
UISETP.GT.OR.X    UP0,      UR5, 0x0, UPT, UP0;
```

__DefOpcode UISETP_UU : [UISETP]
  __Encoding
    field<8,   4> USType stype == UU;
    field<32,  6> UReg urb;
  __OperandInfo
    InList<upg, ura, urb, upp, upq>;
    OutList<upu, upv>;
    Order<upg, upu, upv, ura, urb, upp, upq>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;

__DefOpcode UISETP_UI : [UISETP]
  __Encoding
    field<8,   4> USType stype == UI;
    field<32, 32> SImm32 vb;
  __OperandInfo
    InList<upg, ura, vb, upp, upq>;
    OutList<upu, upv>;
    Order<upg, upu, upv, ura, vb, upp, upq>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;

__DefOpcode UISETP_UC : [UISETP]
  __Encoding
    field<8,   4> USType stype == UC;
    field<32, 22> CMem vb;
  __OperandInfo
    InList<upg, ura, vb, upp, upq>;
    OutList<upu, upv>;
    Order<upg, upu, upv, ura, vb, upp, upq>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;

__DefOptype USEL : [UDP]
  __Encoding
    field<0,  8> Optype optype == USEL;
    field<16,  6> UReg urd;

    field<24, 6> UReg ura;

    field<98,  3> UPred upp;
    field<101,  1> PModi upp.not=False;

  __Syntax
```asm
USEL URd, URa, SrcB, {!}upp      $sched $req ;
```

  __Description
根据谓词upp的值，选择将URa或SrcB的值赋予给URd。

可以认为语义上等价于C语言的三元表达式。

  __OperandInfo
URd和URa来源于UR。

SrcB的合法来源包括UR、Imm32或cmem。

upp来源于UPR，可以带有一个逻辑非修饰符（!），表示对来源取反作为操作数。

  __Semantics
```asm
USEL URd, URa, SrcB, upp:
    URd = upp ? URa : SrcB;
```

  __Examples
```asm
USEL UR0, UR1, UR2, !UP0;
```

__DefOpcode USEL_UU : [USEL]
  __Encoding
    field<8,   4> USType stype == UU;
    field<32,  6> UReg urb;
  __OperandInfo
    InList<upg, ura, urb, upp>;
    OutList<urd>;
    Order<upg, urd, ura, urb, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode USEL_UI : [USEL]
  __Encoding
    field<8,   4> USType stype == UI;
    field<32, 32> SImm32 vb;
  __OperandInfo
    InList<upg, ura, vb, upp>;
    OutList<urd>;
    Order<upg, urd, ura, vb, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode USEL_UC : [USEL]
  __Encoding
    field<8,   4> USType stype == UC;
    field<32, 22> CMem vb;
  __OperandInfo
    InList<upg, ura, vb, upp>;
    OutList<urd>;
    Order<upg, urd, ura, vb, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOptype ULOP3 : [UDP]
  __Encoding
    field<0,    8> Optype optype == ULOP3;
    field<16,   6> UReg urd;
    field<24,   6> UReg ura;
    field<79,   2> EXBool exbool = POR;
    field<82,   8> UImm8  lut;
    field<98,   3> UPred upp;
    field<101,  1> PModi upp.not=False;
    field<106,  3> UPred upu = UPT;

  __Syntax
```asm          
ULOP3.exbool {upu, }URd, URa, SrcB, URc, UImm8Lut, {!}upp      $sched $req ;

.exbool = {.PAND, .POR}
```

  __Description
使用Uniform Data Pipeline对3个输入操作数URa、SrcB和URc的每个bit，按照真值表UImm8Lut指定的输入-输出逻辑映射关系，进行逻辑运算，结果写入URd的对应bit。

允许将计算结果URd与一个输入谓词upp进行指定的逻辑运算，结果写入谓词upu。

  __OperandInfo
URd、URa和URc均来源于UR。

SrcB的合法来源包括UR、Imm32或cmem。

UImm8Lut必须是一个8bit无符号整数的字面值，用于描述输入（URa、SrcB、URc）-输出（URd）的逻辑映射关系，具体解释请参考Semantics部分。

谓词操作数upu和upp都来源于UPR，其中upu的默认值是UPT（可省略），upp允许添加一个逻辑非（!）前缀，表示将来源取反后作为操作数。

  __ModifierInfo
.exbool修饰符的可取值是.PAND或.POR，分别表示将URd的计算结果与输入操作数upp进行逻辑与/逻辑或运算，结果写入输出操作数upu，具体规则请参考Semantics部分。

  __Semantics
UImm8Lut作为真值表的含义，可以参考[[LOP3]]的Semantics部分。

```asm
ULOP3.exbool upu, URd, URa, SrcB, URc, UImm8Lut, upp:
    // 根据真值表UImm8Lut获得输入-输出之间的映射关系
    F = getFunctionFromTable(UImm8Lut);
    URd = F(URa, SrcB, URc);
    // 执行额外的逻辑运算
    if (.exbool == .PAND) {
        upu = (URd != 0) & upp;
    } else {
        upu = (URd != 0) | upp;
    }
```

  __Examples
```asm
ULOP3.POR UR7, UR7, URZ, UR0, 0x1A, !UPT;
```

__DefOpcode ULOP3_UUU : [ULOP3]
  __Encoding
    field<8,   4> USType stype == UUU;
    field<32,  6> UReg urb;
    field<64,  6> UReg urc;
  __OperandInfo
    InList<upg, ura, urb, urc, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, urb, urc, lut, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;

__DefOpcode ULOP3_UIU : [ULOP3]
  __Encoding
    field<8,   4> USType stype == UIU;
    field<32, 32> SImm32 vb;
    field<64,  6> UReg urc;
  __OperandInfo
    InList<upg, ura, vb, urc, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, vb, urc, lut, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;

__DefOpcode ULOP3_UCU : [ULOP3]
  __Encoding
    field<8,   4> USType stype == UCU;
    field<32, 22> CMem vb;
    field<64,  6> UReg urc;
  __OperandInfo
    InList<upg, ura, vb, urc, upp>;
    OutList<urd, upu>;
    Order<upg, urd, upu, ura, vb, urc, lut, upp>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;

__DefOptype UPLOP3 : [UDP]
  __Encoding
    field<0,    8> Optype optype == UPLOP3;
    field<24,   3> UPred upa;
    field<27,   1> PModi upa.not = False;
    field<32,   3> UPred upb;
    field<35,   1> PModi upb.not = False;
    field<64,   3> UPred upc;
    field<67,   1> PModi upc.not = False;

    field<82,   8> UImm8  lut;
    field<106,  3> UPred upu;

  __Syntax
```asm          
UPLOP3 upu, {!}upa, {!}upb, {!}upc, UImm8Lut      $sched $req ;
```

  __Description
使用Uniform Data Pipeline，对3个输入谓词upa、upb和upc（可视为单bit操作数），按照真值表UImm8Lut指定的输入-输出逻辑映射关系，进行逻辑运算，结果写入输出谓词upu。

  __OperandInfo
所有操作数均为谓词，必须来源于UPR。upa、upb和upc允许添加一个逻辑非（!）前缀，表示将来源取反后作为操作数。

UImm8Lut必须是一个UImm8立即数，用于描述输入-输出的逻辑映射关系，具体解释请参考Semantics部分。

  __Semantics
UImm8Lut作为真值表的含义，可以参考[[PLOP3]]的Semantics部分。

```asm
UPLOP3 upu, upa, upb, upc, UImm8Lut:
    // 根据真值表UImm8Lut获得输入-输出之间的映射关系
    F = getFunctionFromTable(UImm8Lut);
    upu = F(upa, upb, upc);
```

  __Examples
```asm
UPLOP3 UP0, UP1, !UP2, UP3, 0x1A;
```

__DefOpcode UPLOP3_X : [UPLOP3]
  __Encoding
    field<8,   4> USType stype == X;
  __OperandInfo
    InList<upg, upa, upb, upc>;
    OutList<upu>;
    Order<upg, upu, upa, upb, upc, lut>;

__DefOptype USHF : [UDP]
  __Encoding
    field<0,   8> Optype optype == USHF;
    field<16,  6> UReg urd;

    field<24,  6> UReg ura;

    field<75,  1> LOHI lohi = LO;
    field<77,  2> SHFDType itype = S32;
    field<80,  1> CWMode cwmod = C;
    field<81,  1> SHFDir direction;

  __Syntax
```asm          
USHF.direction{.lohi}{.cwmod}{.itype} URd, URa, SrcB, SrcC      $sched $req ;

.direction = {.L, .R}
.lohi = {.LO*, .HI}
.cwmod = {.CLAMP*, .WRAP}
.itype = {.S32*, .U32, .S64, .U64}
```

  __Description
使用Uniform Data Pipeline，对2个输入32bit数URa和SrcC进行拼接（低32bit是URa，高32bit是SrcC），根据.direction指定的方向和SrcB指定的位数移位后，输出结果的低32bit或高32bit。

指令名中的SHF是funnel shift的含义。

  __OperandInfo
URd和URa必须来源于UR。

SrcB和SrcC的所有合法来源组合如下：

| SrcB | SrcC |
| :--: | :--: |
| UR  | UR  |
| UR  |Imm32|
|UImm32| UR  |
| UR  |cmem |
|cmem | UR  |

  __ModifierInfo
.direction可取.L或.R，分别表示左移或右移。

.lohi可取.LO（默认值，可省略）或.HI，分别表示输出结果的低32bit或高32bit。

.cwmod可取.CLAMP（默认值，可省略）或.WRAP，分别表示移位的位数超出有效位数的上限N时，采取截断还是循环的处理方式来获得实际移位数:
- .cwmod = .CLAMP：若SrcB > N，则将URa视为N位的整数
- .cwmod = .WRAP ：若SrcB > N，则将URa视为mod(SrcB, N)位的整数

因此，在.CLAMP模式下，移位的位数在0~N之间，而在.WRAP模式下，移位的位数在0~N-1之间。

.itype可取值及其含义如下：

| .itype | 描述 |
| :--: | :--- |
| .S32（默认值，可省略） | 右移时符号扩展，移位的有效位数上限是32 |
| .U32 | 右移时零扩展，移位的有效位数上限是32 |
| .S64 | 右移时符号扩展，移位的有效位数上限是64 |
| .U64 | 右移时零扩展，移位的有效位数上限是64 |

也就是说，.itype是无符号类型时，表示进行逻辑移位，否则进行的都是算术移位。

  __Semantics
```asm
USHF.direction.lohi.cwmod.itype URd, URa, SrcB, SrcC:
    // 将URa与SrcC拼接成64bit数
    UINT64 t;
    t[31:0] = URa;
    t[63:32] = SrcC;
    // 根据.itype确定有效移位位数的上限
    n_ub = (.itype == .S64 || .itype == .U64) ? 64 : 32;
    // 根据.cwmod和SrcB确定有效移位位数
    b = UINT32(SrcB);
    n = (.cwmod == .CLAMP) ? min(n_ub, ) : min(b, n_ub) : mod(b, n_ub);
    // 根据.direction的方向进行移位
    if (.direction == .L) {
        // 左移
        t = t << n;
    } else {
        // 右移n位，并根据.itype决定对高位做符号扩展还是零扩展
        t = signOrZeroExtendShiftRight(t, n, .itype);
    }
    // 根据.lohi，输出低32bit或高32bit
    if (.lohi == .LO) {
        URd = t & 0xFFFFFFFF;
    } else {
        URd = (t >> 32) & 0xFFFFFFFF;
    }
```

  __Examples
```asm
USHF.L.HI.S32 UR7, UR7, 0x24, UR0;  // 由于0x24大于移位数的上限32，在.CLAMP模式下只做32位左移
```

__DefOpcode USHF_UUU : [USHF]
  __Encoding
    field<8,   4> USType stype == UUU;
    field<32,  6> UReg urb;
    field<64,  6> UReg urc;
  __OperandInfo
    InList<upg, ura, urb, urc>;
    OutList<urd>;
    Order<upg, urd, ura, urb, urc>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;

__DefOpcode USHF_UIU : [USHF]
  __Encoding
    field<8,   4> USType stype == UIU;
    field<32, 32> SImm32 vb;
    field<64,  6> UReg urc;
  __OperandInfo
    InList<upg, ura, vb, urc>;
    OutList<urd>;
    Order<upg, urd, ura, vb, urc>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;

__DefOpcode USHF_UUI : [USHF]
  __Encoding
    field<8,   4> USType stype == UUI;
    field<32, 32> SImm32 vc;
    field<64,  6> UReg urb;
  __OperandInfo
    InList<upg, ura, urb, vc>;
    OutList<urd>;
    Order<upg, urd, ura, urb, vc>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<vc> = 32;
    Bitwidth<urd> = 32;

__DefOpcode USHF_UUC : [USHF]
  __Encoding
    field<8,   4> USType stype == UUC;
    field<32, 22> CMem vc;
    field<64,  6> UReg urb;
  __OperandInfo
    InList<upg, ura, urb, vc>;
    OutList<urd>;
    Order<upg, urd, ura, urb, vc>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<vc> = 32;
    Bitwidth<urd> = 32;

__DefOpcode USHF_UCU : [USHF]
  __Encoding
    field<8,   4> USType stype == UCU;
    field<32, 22> CMem vb;
    field<64,  6> UReg urc;
  __OperandInfo
    InList<upg, ura, vb, urc>;
    OutList<urd>;
    Order<upg, urd, ura, vb, urc>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;

__DefOptype UMOV : [UDP]
  __Encoding
    field<0,  8> Optype optype == UMOV;
    field<16,  6> UReg urd;

  __Syntax
```asm          
UMOV{.32} URd, SrcA      $sched $req ;
UMOV.64   URd, URa       $sched $req ;
```

  __Description
将源操作数A的值精确复制给目的操作数URd。

  __OperandInfo
URd必须来源于UR，对于UMOV.64指令，输入URa和输出URd都必须来源于64bit寄存器。

关于如何表示大于32bit位宽的寄存器操作数，请参考[扩展位宽的寄存器操作数](操作数汇编显示规则.md#扩展位宽的寄存器操作数)。

源操作数SrcA的合法来源包括UR、Imm32和cmem。

  __ModifierInfo
UMOV指令的修饰符可以是.32或.64，分别表示UMOV操作的位宽是32bit还是64bit。

默认情况下UMOV指令的操作位宽就是32bit，此时可以省略.32修饰符。

  __Semantics
```asm
UMOV.32 URd, SrcA:
    URd[31:0] = SrcA[31:0];

UMOV.64 URd, URa:
    URd[63:0] = URa[63:0];
```

  __Examples
```asm
UMOV UR0, UR1;
UMOV UR0, 0x114514;   // UR0 = 0x114514
UMOV.64 UR[0:1], UR[2:3]; // UR[0:1] = UR[2:3]
```

__DefOpcode UMOV_U : [UMOV]
  __Encoding
    field<8,   4> USType stype == U;
    field<32,  6> UReg urb;
    field<80, 1> MOVW width = 32;
  __OperandInfo
    InList<upg, urb>;
    OutList<urd>;
    Order<upg, urd, urb>;
    Bitwidth<urb> = 32 + (width=="64")*32;
    Bitwidth<urd> = 32 + (width=="64")*32;

__DefOpcode UMOV_I : [UMOV]
  __Encoding
    field<8,   4> USType stype == I;
    field<32, 32> SImm32 vb;
    field<80, 1> MOVW width = 32;
  __OperandInfo
    InList<upg, vb>;
    OutList<urd>;
    Order<upg, urd, vb>;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32 + (width=="64")*32;
  __Exception
    EncodingError<IllegalBitFieldValue, "UMOV_I doesnot support .64 ."> = width=="64";

__DefOpcode UMOV_C : [UMOV]
  __Encoding
    field<8,   4> USType stype == C;
    field<32, 22> CMem vb;
    field<80, 1> MOVW width = 32;
  __OperandInfo
    InList<upg, vb>;
    OutList<urd>;
    Order<upg, urd, vb>;
    Bitwidth<vb> = 32 + (width=="64")*32;
    Bitwidth<urd> = 32 + (width=="64")*32;

__DefOptype UPRMT : [UDP]
  __Encoding
    field<0,   8> Optype optype == UPRMT;
    field<16,  6> UReg urd;
    field<24,  6> UReg ura;
    field<76,  3> PRMTMode mode = IDX;

  __Syntax
```asm          
UPRMT{.mode} URd, URa, SrcB, SrcC      $sched $req ;

.mode = {.IDX*, .F4E, .B4E, .RC8, .ECL, .ECR, .RC16}
```

  __Description
从32bit输入操作数URa与SrcB中选取4字节输出到URd。

  __OperandInfo
URa和URd必须来源于UR 。

SrcB和SrcC的所有合法来源组合如下：
| SrcB | SrcC |
|:--:|:--:|
| UR  | UR  |
| UR  |Imm32|
|Imm32| UR  |
| UR  |cmem |
|cmem | UR  |

  __ModifierInfo
.mode可取值包括.IDX（默认值，可省略）、.F4E、.B4E、.RC8、.ECL、.ECR和.RC16。

不同取值对应的含义请参考[[PRMT]]的ModifierInfo部分。

  __Semantics
```asm
UPRMT.mode URd, URa, SrcB, SrcC:
    UINT64 t = (SrcB << 32) | URa;
    if (.mode == .IDX) {
        ctl[0] = (SrcC >> 0) & 0xF;
        ctl[1] = (SrcC >> 4) & 0xF;
        ctl[2] = (SrcC >> 8) & 0xF;
        ctl[3] = (SrcC >> 12) & 0xF;
    } else {
        ctl[0] = ctl[1] = ctl[2] = ctl[3] = (SrcC & 0x3);
    }
    // 根据mode从t的8个字节中选择输出到URd的部分
    URd[7:0]   = ReadByte(.mode, ctl[0], t);
    URd[15:8]  = ReadByte(.mode, ctl[1], t);
    URd[23:16] = ReadByte(.mode, ctl[2], t);
    URd[31:24] = ReadByte(.mode, ctl[3], t);
```

  __Examples
```asm
UPRMT UR0, UR1, UR2, 0xABCD;
```

__DefOpcode UPRMT_UUU : [UPRMT]
  __Encoding
    field<8,   4> USType stype == UUU;
    field<32,  6> UReg urb;
    field<64,  6> UReg urc;
  __OperandInfo
    InList<upg, ura, urb, urc>;
    OutList<urd>;
    Order<upg, urd, ura, urb, urc>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UPRMT_UUI : [UPRMT]
  __Encoding
    field<8,   4> USType stype == UUI;
    field<32, 32> SImm32 vc;
    field<64,  6> UReg urb;
  __OperandInfo
    InList<upg, ura, urb, vc>;
    OutList<urd>;
    Order<upg, urd, ura, urb, vc>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<vc> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UPRMT_UIU : [UPRMT]
  __Encoding
    field<8,   4> USType stype == UIU;
    field<32, 32> SImm32 vb;
    field<64,  6> UReg urc;
  __OperandInfo
    InList<upg, ura, vb, urc>;
    OutList<urd>;
    Order<upg, urd, ura, vb, urc>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UPRMT_UUC : [UPRMT]
  __Encoding
    field<8,   4> USType stype == UUC;
    field<32, 22> CMem vc;
    field<64,  6> UReg urb;
  __OperandInfo
    InList<upg, ura, urb, vc>;
    OutList<urd>;
    Order<upg, urd, ura, urb, vc>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<vc> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UPRMT_UCU : [UPRMT]
  __Encoding
    field<8,   4> USType stype == UCU;
    field<32, 22> CMem vb;
    field<64,  6> UReg urc;
  __OperandInfo
    InList<upg, ura, vb, urc>;
    OutList<urd>;
    Order<upg, urd, ura, vb, urc>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;

__DefOptype UPOPC : [UDP]
  __Encoding
    field<0,  8>  Optype optype==UPOPC;
    field<16, 6> UReg urd;

  __Syntax
```asm          
UPOPC URd, {~}SrcB      $sched $req ;
```

  __Description
计算输入32bit操作数SrcB的二进制表示中为1的bit数（即population count），将结果写入32bit无符号整数URd。

  __OperandInfo
URd必须来源于UR。

SrcB可以来源于UR、Imm32和cmem。

SrcB可以选择添加一个按位取反前缀（~），表示对来源按位取反作为输入。

  __Semantics
```asm
UPOPC URd, SrcB:
    UINT32 c = 0;
    while (SrcB != 0) {
        if (SrcB & 0x1) {
            c++;
        }
        a >>= 1;
    }
    URd = c;
```

  __Examples
```asm
UPOPC UR0, UR1;
```

__DefOpcode UPOPC_U : [UPOPC]
  __Encoding
    field<8,  4> USType stype==U;
    field<32, 6> UReg urb;
    field<97, 1> SignModi urb.bitnot=False;
  __OperandInfo
    InList<upg, urb>;
    OutList<urd>;
    Order<upg, urd, urb>;
    Bitwidth<urb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UPOPC_I : [UPOPC]
  __Encoding
    field<8,  4> USType stype==I;
    field<32,32> SImm32 vb;
  __OperandInfo
    InList<upg, vb>;
    OutList<urd>;
    Order<upg, urd, vb>;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UPOPC_C : [UPOPC]
  __Encoding
    field<8,  4> USType stype==C;
    field<32, 22> CMem vb;
    field<97, 1> SignModi vb.bitnot=False;
  __OperandInfo
    InList<upg, vb>;
    OutList<urd>;
    Order<upg, urd, vb>;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOptype UFLO : [UDP]
  __Encoding
    field<0,  8> Optype optype==UFLO;
    field<16, 6> UReg urd;
    field<80, 1> IType itype=S32;
    field<81, 1> FLOSH sh=NoSH;

  __Syntax
```asm          
UFLO{.SH}{.itype} URd, {~}SrcB      $sched $req ;

.itype = {.S32*, .U32}
```

  __Description
计算32bit输入操作数SrcB绝对值的二进制表示的最高非零比特的位置。

即URd = findMostSignificantOneBit(|SrcB|)。

对32bit中各比特的位置，规定最低位的位置是0，最高位是31，以此类推。

特别的，如果SrcB为0，则输出恒定为Rd = 0xFFFFFFFF。

  __OperandInfo
URd必须来源于UR。

SrcB可以来源于UR、Imm32和cmem。

SrcB可以选择添加一个按位取反前缀（~），表示对来源按位取反作为输入。

  __ModifierInfo
.itype表示输入操作数SrcB的类型，可取.S32（默认值，可省略）或.U32。

可选修饰符.SH表示用31减去计算结果输出，表示如果要把最高非零bit左移到所需的移位数。

  __Semantics
```asm
UFLO.type.shOrNot URd, SrcB:
    // 对输入0需要特殊处理
    if (SrcB == 0) {
        URd = 0xFFFFFFFF;
    }
    // 处理非零输入
    if (.type == .S32) {
        SrcB = ~SrcB;
    }
    URd = 0xFFFFFFFF;
    for (i = 31; i >= 0; i--) {
        if (SrcB & (1 << i)) {
            URd = i;
            break;
        }
    }
    // 计算左移位数
    if (.shOrNot == .SH) {
        URd = 31 - URd;
    }
```

  __Examples
```asm
UFLO        UR0, UR1;
UFLO.U32.SH UR1, URZ; // UR1 = 0xFFFFFFFF
```

__DefOpcode UFLO_U : [UFLO]
  __Encoding
    field<8,  4> USType stype==U;
    field<32, 6> UReg urb;
    field<97, 1> SignModi urb.bitnot=False;
  __OperandInfo
    InList<upg, urb>;
    OutList<urd>;
    Order<upg, urd, urb>;
    Bitwidth<urb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UFLO_I : [UFLO]
  __Encoding
    field<8,  4> USType stype==I;
    field<32,32> SImm32 vb;
  __OperandInfo
    InList<upg, vb>;
    OutList<urd>;
    Order<upg, urd, vb>;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UFLO_C : [UFLO]
  __Encoding
    field<8,  4> USType stype==C;
    field<32, 22> CMem vb;
    field<97, 1> SignModi vb.bitnot=False;
  __OperandInfo
    InList<upg, vb>;
    OutList<urd>;
    Order<upg, urd, vb>;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOptype UBREV : [UDP]
  __Encoding
    field<0,  8>  Optype optype==UBREV;
    field<16, 6> UReg urd;

  __Syntax
```asm          
UBREV URd, SrcB      $sched $req ;
```

  __Description
将32bit源操作数SrcB按位取反后输出给URd，即URd = ~SrcB。

  __OperandInfo
32bit操作数URd必须来源于UR。

32bit操作数SrcB的合法来源包括：UR、Imm32和cmem。

  __Semantics
```asm
UBREV URd, SrcB:
    URd = ~SrcB;
```

  __Examples
```asm
UBREV UR0, UR1; // UR0 = ~UR1
```

__DefOpcode UBREV_U : [UBREV]
  __Encoding
    field<8,  4> USType stype==U;
    field<32, 6> UReg urb;
  __OperandInfo
    InList<upg, urb>;
    OutList<urd>;
    Order<upg, urd, urb>;
    Bitwidth<urb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UBREV_I : [UBREV]
  __Encoding
    field<8,  4> USType stype==I;
    field<32,32> SImm32 vb;
  __OperandInfo
    InList<upg, vb>;
    OutList<urd>;
    Order<upg, urd, vb>;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UBREV_C : [UBREV]
  __Encoding
    field<8,  4> USType stype==C;
    field<32, 22> CMem vb;
  __OperandInfo
    InList<upg, vb>;
    OutList<urd>;
    Order<upg, urd, vb>;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOptype UBMSK : [UDP]
  __Encoding
    field<0,  8>  Optype optype==UBMSK;
    field<16, 6> UReg urd;
    field<24, 6> UReg ura;
    field<81, 1> CWMode cwmode=C;

  __Syntax
```asm          
UBMSK.cwmode URd, URa, SrcB      $sched $req ;

.cwmode = {.CLAMP, .WRAP};
```

  __Description
从URa指定的比特位开始，向高位延申的SrcB位填充为1，其他部分填充为0，从而获得一个32bit位宽的掩码，写入URd。具体语义请参考Semantics部分。

  __OperandInfo
所有输入输出操作数都视为32bit无符号整数。

URd和URa必须来源于UR。

SrcB的合法来源包括：UR、UImm32和cmem。

  __ModifierInfo
.cwmode可取.CLAMP或.WRAP，用于控制掩码的bit范围[hi:lo]：

| .cwmode  | [hi:lo]的计算方式 |
| :---|:---|
| .CLAMP | [hi:lo] = [URa+SrcB:URa] |
| .WRAP  | a1=mod(URa,32)，b1=mod(SrcB,32), [hi:lo] = [a1+b1:a1] |

得到[hi:lo]后，与[31:0]进行比较，二者的交集置为1，其余置为0，并将最终结果的低32bit写入URd。

  __Semantics
```asm
UBMSK.mode URd, URa, SrcB:
    // 启用.WRAP时计算掩码范围
    a1 = URa & 0x1f;
    mask0 = (~0) << a1;
    b1 = URb & 0x1f;
    sum = a1 + b1;
    mask1 = (~0) << sum;

    sumOverflow = sum >= 32 ? true : false;
    bitPositionOverflow = false;
    bitWidthOverflow = false;

    // 启用.CLAMP，计算掩码范围
    if (.mode == .CLAMP) {
        if (URa >= 32) {
            bitPositionOverflow = true;
            mask0 = 0;
        }
        if (URb >= 32) {
            bitWidthOverflow = true;
        }
    }

    if (sumOverflow || bitPositionOverflow || bitWidthOverflow) {
        mask1 = 0;
    } else if (b1 == 0) {
        mask1 = ~0;
    }
    // 输出32bit掩码
    URd = mask0 & ~mask1;
```

  __Examples
```asm
UBMSK UR7, UR7, UR0 ;
```

__DefOpcode UBMSK_UU : [UBMSK]
  __Encoding
    field<8,  4> USType stype==UU;
    field<32, 6> UReg urb;
  __OperandInfo
    InList<upg, ura, urb>;
    OutList<urd>;
    Order<upg, urd, ura, urb>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UBMSK_UI : [UBMSK]
  __Encoding
    field<8,  4> USType stype==UI;
    field<32,32> SImm32 vb;
  __OperandInfo
    InList<upg, ura, vb>;
    OutList<urd>;
    Order<upg, urd, ura, vb>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UBMSK_UC : [UBMSK]
  __Encoding
    field<8,  4> USType stype==UC;
    field<32, 22> CMem vb;
  __OperandInfo
    InList<upg, ura, vb>;
    OutList<urd>;
    Order<upg, urd, ura, vb>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOptype USGXT : [UDP]
  __Encoding
    field<0,  8> Optype optype==USGXT;
    field<16, 6> UReg urd;
    field<24, 6> UReg ura;
    field<80, 1> IType itype=S32;
    field<81, 1> CWMode cwmode=C;

  __Syntax
```asm          
USGXT{.cwmode}{.itype} URd, URa, SrcB      $sched $req ;

.itype = {.S32*, .U32}
.cwmode = {.CLAMP*, .WRAP}
```

  __Description
根据SrcB，将URa视为SrcB位的整数，并进行零扩展或符号扩展到32bit位宽，写入URd。

如果SrcB = 0，则输出恒为0。

  __OperandInfo
URa和URd必须来源于UR。

无符号32bit整数SrcB可以来源于UR、UImm32或cmem。

  __ModifierInfo
.itype可以取.S32（默认值，可省略）或.U32，表示对URa进行符号扩展还是零扩展。

.cwmode可以取.CLAMP（默认值，可省略）或.WRAP，表示SrcB指定的位宽大于32时的行为：
- .cwmode = .CLAMP：若SrcB > 32，则将URa视为32位的整数
- .cwmode = .WRAP ：若SrcB > 32，则将URa视为mod(SrcB, 32)位的整数

因此，.CLAMP模式下的URa实际有效位宽可以是0~32，而.WRAP模式下的URa实际有效位宽只能是0~31。

  __Semantics
```asm
USGXT.mode.type URd, URa, SrcB:
    // 根据.mode和SrcB的值，确定URa的实际有效位宽
    bitwidth = UINT32(SrcB);
    if (.mode == .CLAMP) {
        bitwidth = bitwidth > 32 ? 32 : bitwidth;
    } else {
        bitwidth = mod(bitwidth, 32);
    }
    // 处理0位宽的情况
    if (bitwidth == 0) {
        URd = 0x00000000;
    // 符号扩展或零扩展到32bit
    } else if (.type == .U32) {
        URd = 0x00000000 | URa[bitwidth-1:0];
    } else {
        // 拷贝bitwidth位至URd
        URd = URa & ((1 << bitwidth) - 1);
        // 检测符号位
        if ((URd >> (bitwidth - 1)) & 0x1 == 1) {
            // 符号扩展
            URd = URd | (~((1 << bitwidth) - 1));
        }
    }
```

  __Examples
```asm
USGXT     UR0, UR1, 0x3 ;   // 3bit符号扩展到32bit
USGXT.U32 UR2, UR3, 0x10;   // 16bit零扩展到32bit
```

__DefOpcode USGXT_UU : [USGXT]
  __Encoding
    field<8,  4> USType stype==UU;
    field<32, 6> UReg urb;
  __OperandInfo
    InList<upg, ura, urb>;
    OutList<urd>;
    Order<upg, urd, ura, urb>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode USGXT_UI : [USGXT]
  __Encoding
    field<8,  4> USType stype==UI;
    field<32,32> SImm32 vb;
  __OperandInfo
    InList<upg, ura, vb>;
    OutList<urd>;
    Order<upg, urd, ura, vb>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOpcode USGXT_UC : [USGXT]
  __Encoding
    field<8,  4> USType stype==UC;
    field<32, 22> CMem vb;
  __OperandInfo
    InList<upg, ura, vb>;
    OutList<urd>;
    Order<upg, urd, ura, vb>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urd> = 32;

__DefOptype SETUGPR : [UDP]
  __Encoding
    field<0,  8> Optype optype == SETUGPR;
    field<24, 6> UReg ura;

  __Syntax
```asm          
SETUGPR UR[URa{+SImm7}] URb      $sched $req $wsb ;
```

  __Description
通过动态索引，而非UR名，间接修改UR的值，即UR[URa+SImm7] = URb。

  __OperandInfo
URb必须来源于GPR，表示要赋予目的寄存器的值。

URa必须来源于UR，表示要修改的目的寄存器的索引值。

允许选择性地使用一个7bit的有符号立即数字面值SImm7，表示在URa基础上的偏移量。

如果要修改的UR索引值超出硬件允许使用的UR范围，该指令会触发异常。

  __Semantics
```asm
SETUGPR UR[URa+SImm7] URb:
    UR[URa+SImm7] = URb;
```

  __Examples
```asm
SETUGPR UR[UR2], UR0;      // UR[UR2] = UR0
SETUGPR UR[UR2+0x1], UR1;  // UR[UR2+1] = UR1
```

__DefOpcode SETUGPR_UIU : [SETUGPR]
  __Encoding
    field<8,  4> USType stype == UIU;
    field<64, 6> UReg urb;
    field<32, 7> SImm7 uridx;
  __OperandInfo
    InList<upg, ura, urb>;
    OutList<>;
    Order<upg, UR[urb, uridx], ura>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;

__DefOptype GETUGPR : [UDP]
  __Encoding
    field<0,  8> Optype optype == GETUGPR;
    field<16,  6> UReg urd;

  __Syntax
```asm          
GETUGPR URd, UR[URa{+SImm7}]      $sched $req $wsb ;
```

  __Description
通过动态索引，而非UR名，间接读取UR的值到指定的输出UR中，即URd = UR[URa+SImm7]。

  __OperandInfo
URd必须来源于UR。

URa必须来源于UR，表示要读取的目的寄存器的索引值。

允许选择性地使用一个7bit的有符号立即数字面值SImm7，表示在URa基础上的偏移量。

如果要访问的UR索引值超出硬件允许的UR范围，该指令将触发异常。

  __Semantics
```asm
GETUGPR URd, UR[URa+SImm7]:
    URd = UR[URa+SImm7];
```

  __Examples
```asm
GETUGPR UR0, UR[UR2];          // UR0 = UR[UR2]，例如若UR2 = 0x4，则UR0 = UR4
GETUGPR UR1, UR[UR2+0x1];      // UR1 = UR[UR2+1]，例如若UR2 = 0x4，则UR1 = UR5
```

__DefOpcode GETUGPR_UI : [GETUGPR]
  __Encoding
    field<8,  4> USType stype == UI;
    field<64, 6> UReg urb;
    field<32, 7> SImm7 uridx;
  __OperandInfo
    InList<upg, urb>;
    OutList<urd>;
    Order<upg, urd, UR[urb, uridx]>;
    Bitwidth<urb> = 32;
    Bitwidth<urd> = 32;

__DefOptype UF2FP : [UDP]
  __Encoding
    field<0, 8> Optype optype == UF2FP;
    field<16, 6> UReg urd;
    field<24, 6> UReg ura;
    field<64, 6> UReg urc;

  __Semantics

    TODO:

__DefOpcode UF2FP_UUU : [UF2FP]
  __Encoding
    field<8, 4> USType stype == UUU;
    field<32, 6> UReg urb;
  __OperandInfo
    InList<upg, ura, urb, urc>;
    OutList<urd>;
    Order<upg, urd, ura, urb, urc>;
    Bitwidth<ura> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;

__DefOpcode UF2FP_UCU : [UF2FP]
  __Encoding
    field<8, 4> USType stype == UCU;
    field<32, 22> CMem vb;
  __OperandInfo
    InList<upg, ura, vb, urc>;
    OutList<urd>;
    Order<upg, urd, ura, vb, urc>;
    Bitwidth<ura> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<urc> = 32;
    Bitwidth<urd> = 32;
